home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / WINDOWS / WC_30P.ARJ / DDE_SDK.ZI$ / MATH.C < prev    next >
Text File  |  1991-10-17  |  12KB  |  495 lines
  1. // MATH.C -- Here is where the nitty gritty math part comes into play
  2.  
  3. #include <windows.h>
  4. #include <stdlib.h>
  5. #include "payroll.h"
  6. #include "basedefs.h"
  7.  
  8. extern int CentsPerDollar;
  9. extern HWND   ghWnd;
  10. extern char   cComma, cCurrency, cDecimal;
  11. extern char   szCaptionName[];
  12.  
  13. void Add      ( PMONEY Sum,
  14.                 MONEY  Adder1, 
  15.                 MONEY  Adder2 );
  16.  
  17. void Subtract ( PMONEY  Difference,
  18.                 MONEY   Subber1, 
  19.                 MONEY   Subber2 );
  20.  
  21. BOOL bFigureDollarAmount ( LPSTR szIDD_AMOUNT, PMONEY pfAmount );
  22. int ItoA ( char *szString );
  23. int CentsItoA ( char *szString );
  24. LONG LtoA ( char *szString );
  25. void DollarsCents ( MONEY Cash, char *szBuckage, BYTE Flags );
  26.  
  27.  
  28. //********************************************************************
  29. void Add      ( PMONEY Sum,
  30.                 MONEY  Adder1, 
  31.                 MONEY  Adder2 )
  32. {
  33.   BOOL Negative;
  34.  
  35.   Negative = FALSE;
  36.  
  37.   // Special case 1: Adder 1 is negative, Adder 2 is positive
  38.  
  39.   if (
  40.       (( Adder1.Dollars < 0 ) || ( Adder1.Cents < 0 ))
  41.       && 
  42.       (( Adder2.Dollars >= 0 ) && (Adder2.Cents >= 0))
  43.      )
  44.     {
  45.     if (Adder1.Cents < 0)  // Tiny case, negative cents
  46.       {
  47.       if (Adder2.Dollars > 0)  // This will bring us to positive for sure
  48.         {
  49.         Adder2.Cents += CentsPerDollar;
  50.         (Adder2.Dollars)--;
  51.         }
  52.       }
  53.     else
  54.       {
  55.       Adder1.Dollars = 0L - (Adder1.Dollars);
  56.       Subtract ( Sum, Adder2, Adder1 );
  57.       return;
  58.       }
  59.     }
  60.  
  61.   // Special case 2: Adder 2 is negative, Adder 1 is positive
  62.  
  63.   if (
  64.       (( Adder2.Dollars < 0 ) || (Adder2.Cents < 0))
  65.       && 
  66.       (( Adder1.Dollars >= 0 ) && ( Adder1.Cents >= 0 ))
  67.      )
  68.     {
  69.     if (Adder2.Cents < 0)  // Tiny case, negative cents
  70.       {
  71.       if (Adder1.Dollars > 0)  // This will bring us to positive for sure
  72.         {
  73.         Adder1.Cents += CentsPerDollar;
  74.         (Adder1.Dollars)--;
  75.         }
  76.       }
  77.     else
  78.       {
  79.       Adder2.Dollars = 0L - (Adder2.Dollars);
  80.       Subtract ( Sum, Adder1, Adder2 );
  81.       return;
  82.       }
  83.     }
  84.  
  85.   // Special case 3: Adder 1 is negative, Adder 2 is negative
  86.  
  87.   if (
  88.       (( Adder2.Dollars < 0 ) || (Adder2.Cents < 0))
  89.       && 
  90.       (( Adder1.Dollars < 0 ) || (Adder1.Cents < 0))
  91.      )
  92.     {
  93.     Negative = TRUE;
  94.  
  95.     Adder1.Dollars = 0L - Adder1.Dollars;
  96.     Adder2.Dollars = 0L - Adder2.Dollars;
  97.     if (Adder1.Cents < 0) Adder1.Cents = 0 - Adder1.Cents;
  98.     if (Adder2.Cents < 0) Adder2.Cents = 0 - Adder2.Cents;
  99.     }
  100.  
  101.   if ( (Sum->Cents = (Adder1.Cents + Adder2.Cents)) >= CentsPerDollar )
  102.     {
  103.     (Sum->Cents) -= CentsPerDollar;
  104.     if (Adder1.Dollars >= 0)
  105.       (Adder1.Dollars)++;   // Add the carry arbitralily to one of the adders
  106.     else
  107.       (Adder1.Dollars)--;   // Add the carry arbitralily to one of the adders
  108.     }
  109.  
  110.   Sum->Dollars = Adder1.Dollars + Adder2.Dollars;
  111.  
  112.   if (Negative)
  113.     {
  114.     Sum->Dollars = 0L - Sum->Dollars;
  115.     if (!(Sum->Dollars))
  116.       Sum->Cents = 0 - Sum->Cents;
  117.     }
  118. }
  119. //********************************************************************
  120. void Sub      ( PMONEY  Difference,
  121.                 MONEY   Subber1, 
  122.                 MONEY   Subber2 )
  123.  
  124. {
  125.   // Special Case: Subtract a negative number from a number
  126.  
  127.   if (
  128.       (Subber2.Dollars < 0L) ||
  129.       (Subber2.Cents   < 0)
  130.      )
  131.     {
  132.     if (Subber2.Dollars)
  133.       Subber2.Dollars = 0L - Subber2.Dollars;
  134.     else
  135.       Subber2.Cents = 0 - Subber2.Cents;
  136.     Add ( Difference, Subber1, Subber2 );
  137.  
  138.     return;
  139.     }
  140.  
  141.   if (Subber1.Cents < Subber2.Cents)    // Borrow
  142.     {
  143.     (Subber1.Cents)   += CentsPerDollar;
  144.     (Subber1.Dollars)--;
  145.     }
  146.  
  147.   Difference->Cents   = Subber1.Cents   - Subber2.Cents;
  148.   Difference->Dollars = Subber1.Dollars - Subber2.Dollars;
  149.  
  150. }
  151. //********************************************************************
  152. void Subtract ( PMONEY  Difference,
  153.                 MONEY   Subber1, 
  154.                 MONEY   Subber2 )
  155. {
  156.   BOOL Negative;
  157.  
  158.   // Special case #1: subtract 0
  159.  
  160.   if ((!(Subber2.Dollars)) && (!(Subber2.Cents)))
  161.     {
  162.     Difference->Dollars = Subber1.Dollars;
  163.     Difference->Cents   = Subber1.Cents;
  164.     return;
  165.     }
  166.  
  167.   // Special case #2: subtract positive from a negative: Dollars
  168.  
  169.   if (Subber1.Dollars < 0)
  170.     {
  171.     Subber1.Dollars = 0L - Subber1.Dollars;
  172.     Add ( Difference, Subber1, Subber2 );
  173.     Difference->Dollars = 0L - Difference->Dollars;
  174.     return;
  175.     }
  176.  
  177.   if (Subber1.Cents < 0)  // this is only for tiny negative numbers
  178.     {
  179.     Subber1.Cents = 0 - Subber1.Cents;
  180.     Add ( Difference, Subber1, Subber2 );
  181.     Difference->Dollars = 0L - Difference->Dollars;
  182.     return;
  183.     }
  184.  
  185.   // If we get here, then Subber1 MUST be a postive number
  186.  
  187.   Negative = FALSE;
  188.  
  189.   if (Subber1.Dollars < Subber2.Dollars ) Negative = TRUE;
  190.  
  191.   if (Subber1.Dollars == Subber2.Dollars )
  192.     if (Subber1.Cents < Subber2.Cents )     Negative = TRUE;
  193.  
  194.   if (!Negative)
  195.     Sub (Difference, Subber1, Subber2);
  196.   else
  197.     {
  198.     Sub (Difference, Subber2, Subber1);
  199.     if (Difference->Dollars)
  200.       Difference->Dollars = 0L - Difference->Dollars;
  201.     else
  202.       Difference->Cents = 0 - Difference->Cents;
  203.     }
  204. }
  205. //*************************************************************************
  206. //
  207. //   Parses a string into dollars and cents
  208. //
  209. //*************************************************************************
  210. BOOL bFigureDollarAmount ( LPSTR szIDD_AMOUNT, PMONEY pfAmount )
  211. {
  212.   int   i, j, Cents;
  213.   HWND  hWnd;
  214.   char  szStrippedText[64];
  215.   BOOL  BadNumber;
  216.   char  *pToken;
  217.   LONG  Dollars;
  218.   
  219.   j = 0;
  220.   BadNumber = FALSE;
  221.  
  222.   for ( i = 0; i < lstrlen ( (LPSTR)szIDD_AMOUNT ); i++ )
  223.     switch ( szIDD_AMOUNT[i] )
  224.       {
  225.       case '-': hWnd = GetFocus();
  226.                 MessageBox ( ghWnd, "Negative Sign Unneccessary", szCaptionName, MB_OK | MB_ICONHAND );
  227.                 SetFocus ( hWnd );
  228.                 break;
  229.  
  230.       case ' ': break; // ignore spaces
  231.  
  232.       case 'o':
  233.       case 'O': szStrippedText[j] = '0'; j++; BadNumber = TRUE; break;
  234.  
  235.       case 'i':
  236.       case 'I':
  237.       case 'l':
  238.       case 'L': szStrippedText[j] = '1'; j++; BadNumber = TRUE; break;
  239.  
  240.       case '0':
  241.       case '1':
  242.       case '2':
  243.       case '3':
  244.       case '4':
  245.       case '5':
  246.       case '6':
  247.       case '7':
  248.       case '8':
  249.       case '9': szStrippedText[j] = szIDD_AMOUNT[i]; j++; break;
  250.  
  251.       default : if (
  252.                      (cComma    == szIDD_AMOUNT[i]) ||  // ignore commas
  253.                      (cCurrency == szIDD_AMOUNT[i])     // ignore currency
  254.                    )
  255.                   {
  256.                   // do nothing
  257.                   }
  258.                 else
  259.                   {
  260.                   if (cDecimal == szIDD_AMOUNT[i])
  261.                     {
  262.                     szStrippedText[j] = 0; 
  263.                     j++;
  264.                     }
  265.                   else
  266.                     {
  267.                     BadNumber = TRUE;
  268.                     }
  269.                   }
  270.                 break;
  271.       }
  272.  
  273.   szStrippedText[j] = 0;
  274.   j++;
  275.   szStrippedText[j] = 26;   // Mark and EOF
  276.  
  277.   pToken = szStrippedText;
  278.  
  279.   if (*pToken != 26)  
  280.     {
  281.     Dollars = LtoA ( pToken );
  282.     while (*pToken) pToken++;
  283.     pToken++;
  284.     }
  285.   else
  286.     Dollars = 0;
  287.  
  288.   if (*pToken != 26)  
  289.     {
  290.     Cents = CentsItoA ( pToken );
  291.     while (*pToken) pToken++;
  292.     pToken++;
  293.     }
  294.   else
  295.     Cents = 0;
  296.  
  297.   if (Cents >= CentsPerDollar)   
  298.     {
  299.     while ((LONG)Cents > (10L*(LONG)CentsPerDollar)) Cents /= 10;
  300.     Cents += 5;  // round the number
  301.     Cents /= 10;
  302.     BadNumber = TRUE;
  303.     }
  304.  
  305.   pfAmount->Dollars = Dollars;
  306.   pfAmount->Cents   = Cents;
  307.  
  308.   return !BadNumber;
  309. }
  310. //*************************************************************************
  311. //
  312. //  int ItoA (szString)
  313. //
  314. //*************************************************************************
  315.  
  316. int ItoA ( char *szString )
  317. {
  318.   int Len = lstrlen ( (LPSTR)szString );
  319.   int Value, Total, i;
  320.  
  321.   Value = 1;
  322.   Total = 0;  
  323.   Len--;
  324.  
  325.   for ( i = 0; i < Len; i++ ) Value *= 10;
  326.  
  327.   while (*szString)
  328.     {
  329.     Total += Value * (*szString - '0');
  330.     Value /= 10;
  331.     szString++;
  332.     }
  333.  
  334.   return Total;
  335. }
  336. //*************************************************************************
  337. //
  338. //  int ItoA (szString)
  339. //
  340. //*************************************************************************
  341.  
  342. int CentsItoA ( char *szString )
  343. {
  344.   int Len = lstrlen ( (LPSTR)szString );
  345.   int OldLen = Len;
  346.   int Value, Total, i;
  347.  
  348.   Value = 1;
  349.   Total = 0;  
  350.   Len--;
  351.  
  352.   for ( i = 0; i < Len; i++ ) Value *= 10;
  353.  
  354.   while (*szString)
  355.     {
  356.     Total += Value * (*szString - '0');
  357.     Value /= 10;
  358.     szString++;
  359.     }
  360.  
  361.   if (1 == OldLen) Total *= 10;  
  362.  
  363.   return Total;
  364. }
  365. //*************************************************************************
  366. //
  367. //  int LtoA (szString) -- Uses no LONG multiplication/division
  368. //
  369. //*************************************************************************
  370.  
  371. LONG LtoA ( char *szString )
  372. {
  373.   int  Len = lstrlen ( (LPSTR)szString );
  374.  
  375.   LONG Values[10] = {          1L,
  376.                               10L,
  377.                              100L,
  378.                             1000L,
  379.                            10000L,
  380.                           100000L,
  381.                          1000000L,
  382.                         10000000L,
  383.                        100000000L,
  384.                       1000000000L };
  385.  
  386.   LONG Total;
  387.   int  j;
  388.  
  389.   Total = 0;  
  390.   Len--;
  391.  
  392.   while (*szString)
  393.     {
  394.     for ( j = 0; j < (*szString - '0'); j++ ) Total += Values[Len];
  395.     Len--;
  396.     szString++;
  397.     }
  398.  
  399.   return Total;
  400. }
  401.  
  402. //*************************************************************************
  403. //
  404. //
  405. //
  406. //*************************************************************************
  407.  
  408. void DollarsCents ( MONEY Cash, char *szBuckage, BYTE Flags )
  409. {
  410.   char szDollars[21];
  411.   BOOL bNegative;
  412.   int  NumDigits;
  413.   int  i, j;
  414.   LONG Dollars= Cash.Dollars;
  415.   int  Cents  = Cash.Cents;
  416.   BOOL bCurrency = (BOOL)(Flags & CURRENCY);
  417.   BOOL bCommas   = (BOOL)(Flags & COMMAS);
  418.  
  419.   bNegative = FALSE;
  420.  
  421.   if (Dollars < 0L) // Negative money
  422.     {
  423.     bNegative = TRUE;
  424.     Dollars = 0 - Dollars;
  425.     }
  426.  
  427.   if (Cents < 0) // Nagative money, Vol II
  428.     {
  429.     bNegative = TRUE;
  430.     Cents = -1 * Cents;
  431.     }
  432.  
  433.   wsprintf ( szDollars, "%ld", Dollars );
  434.  
  435.   NumDigits = lstrlen ( szDollars );
  436.  
  437.   j = 0;
  438.  
  439.   if (bNegative)
  440.     {
  441.     szBuckage[j] = '-';
  442.     j++;
  443.     }
  444.  
  445.   if (bCurrency)
  446.     {
  447.     szBuckage[j] = cCurrency;
  448.     j++;
  449.     }
  450.  
  451.   for ( i = 0; i < NumDigits; i++ )
  452.     {
  453.     szBuckage[j] = szDollars[i];
  454.     j++;
  455.     if (
  456.          (!((NumDigits-i-1) % 3))
  457.          && 
  458.          (i != (NumDigits-1))
  459.          &&
  460.          (bCommas)
  461.        )
  462.       {
  463.       if (!cComma) cComma = ',';
  464.       szBuckage[j] = cComma;
  465.       j++;
  466.       }
  467.     }
  468.  
  469.   if (CentsPerDollar > 1)
  470.     {
  471.     szBuckage[j] = cDecimal;
  472.     j++;
  473.     }
  474.  
  475.   switch (CentsPerDollar)
  476.     {
  477.     case 10000: szBuckage[j] = (char)((Cents/1000)+'0');
  478.                 j++;
  479.                 Cents %= 1000;
  480.     case  1000: szBuckage[j] = (char)((Cents/100)+'0');
  481.                 j++;
  482.                 Cents %= 100;
  483.     case   100: szBuckage[j] = (char)((Cents/10)+'0');
  484.                 j++;
  485.                 Cents %= 10;
  486.     case    10: szBuckage[j] = (char)(Cents+'0');
  487.                 j++;
  488.     }
  489.  
  490.   szBuckage[j] = 0;
  491.  
  492. }
  493.  
  494.  
  495.